package Z04FanXin.FX02CanFanXinClass;

import Z006ClassAndObject.CO002JiCheng.Item;


import Z007InterfaceAndExtends.O01InterfaceJiekou.ADHero;
import Z007InterfaceAndExtends.O01InterfaceJiekou.APHero;
import Z007InterfaceAndExtends.O01InterfaceJiekou.Hero;


import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class FXTestStack {}

class MyStack<T>{
    LinkedList<T> values = new LinkedList<T>();

    public void push(T t){
        values.addLast(t);
    }

    public T pull(){
        return values.removeLast();
    }

    public T peek(){
        return values.getLast();
    }

    public static void main(String[] args) {
        // 在声明这个Stack的时候，使用泛型<Hero>就表示该Stack只能放Hero
        MyStack<Hero> itemStack = new MyStack<>();
        // 不能放Item
        // itemStack.push(new Item());
        itemStack.push(new Hero());

        MyStack<Item> itemMyStack = new MyStack<>();
        itemMyStack.push(new Item());
        // 不能放Hero
        // itemMyStack.push(new Hero());


    }
}

class Test{
    public static void main(String[] args) {
        // 前面太乱了，因此记得导入同一包的类
        ArrayList<APHero> apHerolist = new ArrayList<APHero>();
        apHerolist.add(new APHero());
        ArrayList<? extends Hero> heroList = apHerolist;
        // ? extends Hero 表示这是一个Hero泛型的子类泛型
        // heroList 的泛型可以是Hero
        // heroList 的泛型可以使APHero
        // heroList 的泛型可以使ADHero
        // 可以确凿的是，从heroList取出来的对象，一定是可以转型成Hero的
        Hero h = heroList.get(0);
        // 但是不能放入内容

        // heroList.add(new APHero());
        // 编译错误，因为herolist的泛型有可能是APHero
    }
}   // 在这里练习了通配符

class Test1{
    public static void main(String[] args) {
        ArrayList<? super Hero> heroList = new ArrayList<Object>();
        //? super Hero 表示 heroList的泛型是Hero或者其父类泛型
        //heroList 的泛型可以是Hero
        //heroList 的泛型可以是Object
        //所以就可以插入Hero
        heroList.add(new Hero());
        heroList.add(new APHero());
        heroList.add(new ADHero());
        // 但是不能从里面取出数据来，因为其翻新可能是Object
        // 而Object强行转换为Hero会失败
        // Hero h = heroList.get(0);
    }
}  // 在这里练习通配符super

class Test2{
    public static void main(String[] args) {
        ArrayList<APHero> APHeroList = new ArrayList<APHero>();
        //?泛型通配符，表示任意泛型
        ArrayList<?> generalist = APHeroList;
        // ?的缺陷1： 既然?代表任意泛型，那么换句话说，
        // 你就不知道这个容器里面是什么类型
        // 所以只能以Object的形式取出来
        Object o = generalist.get(0);
        // ?的缺陷2： 既然?代表任意泛型，
        // 那么既有可能是Hero,也有可能是Item
        // 所以，放哪种对象进去，都有风险，
        // 结果就什么什么类型的对象，都不能放进去
        // generalist.add(new Item());
        //编译错误 因为?代表任意泛型，很有可能不是Item
        // generalist.add(new ADHero());
        //编译错误 因为?代表任意泛型，很有可能不是ADHero
        // generalist.add(new APHero());
        //编译错误 因为?代表任意泛型，很有可能不是APHero



    }
}

class Test3{

    private static void iterate(ArrayList<Hero> hs) {
        for (Hero hero : hs ){
          //  System.out.println(hero.name);
        }
    }

    private static void iterateAD(ArrayList<ADHero> adhs) {
        for (Hero hero : adhs){
          //  System.out.println(hero.name);
        }
    }

    private static void iterateAP(ArrayList<APHero> aphs) {
        for (Hero hero : aphs){
          //  System.out.println(hero.name);
        }
    }

    public static void main(String[] args) {

        ArrayList<Hero> hs = new ArrayList<>();
        ArrayList<APHero> aphs = new ArrayList<>();
        ArrayList<ADHero> adhs = new ArrayList<>();

        iterate(hs);
        iterateAD(adhs);
        iterateAP(aphs);


    }




}